sound/core/seq/seq_ports.c

   1 /*
   2  *   ALSA sequencer Ports
   3  *   Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
   4  *                         Jaroslav Kysela <perex@perex.cz>
   5  *
   6  *
   7  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU General Public License as published by
   9  *   the Free Software Foundation; either version 2 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20  *
  21  */
  22
  23 #include <sound/core.h>
  24 #include <linux/slab.h>
  25 #include <linux/module.h>
  26 #include "seq_system.h"
  27 #include "seq_ports.h"
  28 #include "seq_clientmgr.h"
  29
  30 /*
  31
  32    registration of client ports
  33
  34  */
  35
  36
  37 /*
  38
  39 NOTE: the current implementation of the port structure as a linked list is
  40 not optimal for clients that have many ports. For sending messages to all
  41 subscribers of a port we first need to find the address of the port
  42 structure, which means we have to traverse the list. A direct access table
  43 (array) would be better, but big preallocated arrays waste memory.
  44
  45 Possible actions:
  46
  47 1) leave it this way, a client does normaly does not have more than a few
  48 ports
  49
  50 2) replace the linked list of ports by a array of pointers which is
  51 dynamicly kmalloced. When a port is added or deleted we can simply allocate
  52 a new array, copy the corresponding pointers, and delete the old one. We
  53 then only need a pointer to this array, and an integer that tells us how
  54 much elements are in array.
  55
  56 */
  57
  58 /* return pointer to port structure - port is locked if found */
  59 struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client,
  60                                                  int num)
  61 {
  62         struct snd_seq_client_port *port;
  63
  64         if (client == NULL)
  65                 return NULL;
  66         read_lock(&client->ports_lock);
  67         list_for_each_entry(port, &client->ports_list_head, list) {
  68                 if (port->addr.port == num) {
  69                         if (port->closing)
  70                                 break; /* deleting now */
  71                         snd_use_lock_use(&port->use_lock);
  72                         read_unlock(&client->ports_lock);
  73                         return port;
  74                 }
  75         }
  76         read_unlock(&client->ports_lock);
  77         return NULL;            /* not found */
  78 }
  79
  80
  81 /* search for the next port - port is locked if found */
  82 struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client,
  83                                                        struct snd_seq_port_info *pinfo)
  84 {
  85         int num;
  86         struct snd_seq_client_port *port, *found;
  87
  88         num = pinfo->addr.port;
  89         found = NULL;
  90         read_lock(&client->ports_lock);
  91         list_for_each_entry(port, &client->ports_list_head, list) {
  92                 if (port->addr.port < num)
  93                         continue;
  94                 if (port->addr.port == num) {
  95                         found = port;
  96                         break;
  97                 }
  98                 if (found == NULL || port->addr.port < found->addr.port)
  99                         found = port;
 100         }
 101         if (found) {
 102                 if (found->closing)
 103                         found = NULL;
 104                 else
 105                         snd_use_lock_use(&found->use_lock);
 106         }
 107         read_unlock(&client->ports_lock);
 108         return found;
 109 }
 110
 111
 112 /* initialize snd_seq_port_subs_info */
 113 static void port_subs_info_init(struct snd_seq_port_subs_info *grp)
 114 {
 115         INIT_LIST_HEAD(&grp->list_head);
 116         grp->count = 0;
 117         grp->exclusive = 0;
 118         rwlock_init(&grp->list_lock);
 119         init_rwsem(&grp->list_mutex);
 120         grp->open = NULL;
 121         grp->close = NULL;
 122 }
 123
 124
 125 /* create a port, port number is returned (-1 on failure) */
 126 struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
 127                                                 int port)
 128 {
 129         unsigned long flags;
 130         struct snd_seq_client_port *new_port, *p;
 131         int num = -1;
 132
 133         /* sanity check */
 134         if (snd_BUG_ON(!client))
 135                 return NULL;
 136
 137         if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) {
 138                 pr_warn("ALSA: seq: too many ports for client %d\n", client->number);
 139                 return NULL;
 140         }
 141
 142         /* create a new port */
 143         new_port = kzalloc(sizeof(*new_port), GFP_KERNEL);
 144         if (! new_port) {
 145                 pr_debug("ALSA: seq: malloc failed for registering client port\n");
 146                 return NULL;    /* failure, out of memory */
 147         }
 148         /* init port data */
 149         new_port->addr.client = client->number;
 150         new_port->addr.port = -1;
 151         new_port->owner = THIS_MODULE;
 152         sprintf(new_port->name, "port-%d", num);
 153         snd_use_lock_init(&new_port->use_lock);
 154         port_subs_info_init(&new_port->c_src);
 155         port_subs_info_init(&new_port->c_dest);
 156
 157         num = port >= 0 ? port : 0;
 158         mutex_lock(&client->ports_mutex);
 159         write_lock_irqsave(&client->ports_lock, flags);
 160         list_for_each_entry(p, &client->ports_list_head, list) {
 161                 if (p->addr.port > num)
 162                         break;
 163                 if (port < 0) /* auto-probe mode */
 164                         num = p->addr.port + 1;
 165         }
 166         /* insert the new port */
 167         list_add_tail(&new_port->list, &p->list);
 168         client->num_ports++;
 169         new_port->addr.port = num;      /* store the port number in the port */
 170         write_unlock_irqrestore(&client->ports_lock, flags);
 171         mutex_unlock(&client->ports_mutex);
 172         sprintf(new_port->name, "port-%d", num);
 173
 174         return new_port;
 175 }
 176
 177 /* */
 178 enum group_type {
 179         SRC_LIST, DEST_LIST
 180 };
 181
 182 static int subscribe_port(struct snd_seq_client *client,
 183                           struct snd_seq_client_port *port,
 184                           struct snd_seq_port_subs_info *grp,
 185                           struct snd_seq_port_subscribe *info, int send_ack);
 186 static int unsubscribe_port(struct snd_seq_client *client,
 187                             struct snd_seq_client_port *port,
 188                             struct snd_seq_port_subs_info *grp,
 189                             struct snd_seq_port_subscribe *info, int send_ack);
 190
 191
 192 static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr,
 193                                                    struct snd_seq_client **cp)
 194 {
 195         struct snd_seq_client_port *p;
 196         *cp = snd_seq_client_use_ptr(addr->client);
 197         if (*cp) {
 198                 p = snd_seq_port_use_ptr(*cp, addr->port);
 199                 if (! p) {
 200                         snd_seq_client_unlock(*cp);
 201                         *cp = NULL;
 202                 }
 203                 return p;
 204         }
 205         return NULL;
 206 }
 207
 208 /*
 209  * remove all subscribers on the list
 210  * this is called from port_delete, for each src and dest list.
 211  */
 212 static void clear_subscriber_list(struct snd_seq_client *client,
 213                                   struct snd_seq_client_port *port,
 214                                   struct snd_seq_port_subs_info *grp,
 215                                   int grptype)
 216 {
 217         struct list_head *p, *n;
 218
 219         list_for_each_safe(p, n, &grp->list_head) {
 220                 struct snd_seq_subscribers *subs;
 221                 struct snd_seq_client *c;
 222                 struct snd_seq_client_port *aport;
 223
 224                 if (grptype == SRC_LIST) {
 225                         subs = list_entry(p, struct snd_seq_subscribers, src_list);
 226                         aport = get_client_port(&subs->info.dest, &c);
 227                 } else {
 228                         subs = list_entry(p, struct snd_seq_subscribers, dest_list);
 229                         aport = get_client_port(&subs->info.sender, &c);
 230                 }
 231                 list_del(p);
 232                 unsubscribe_port(client, port, grp, &subs->info, 0);
 233                 if (!aport) {
 234                         /* looks like the connected port is being deleted.
 235                          * we decrease the counter, and when both ports are deleted
 236                          * remove the subscriber info
 237                          */
 238                         if (atomic_dec_and_test(&subs->ref_count))
 239                                 kfree(subs);
 240                 } else {
 241                         /* ok we got the connected port */
 242                         struct snd_seq_port_subs_info *agrp;
 243                         agrp = (grptype == SRC_LIST) ? &aport->c_dest : &aport->c_src;
 244                         down_write(&agrp->list_mutex);
 245                         if (grptype == SRC_LIST)
 246                                 list_del(&subs->dest_list);
 247                         else
 248                                 list_del(&subs->src_list);
 249                         up_write(&agrp->list_mutex);
 250                         unsubscribe_port(c, aport, agrp, &subs->info, 1);
 251                         kfree(subs);
 252                         snd_seq_port_unlock(aport);
 253                         snd_seq_client_unlock(c);
 254                 }
 255         }
 256 }
 257
 258 /* delete port data */
 259 static int port_delete(struct snd_seq_client *client,
 260                        struct snd_seq_client_port *port)
 261 {
 262         /* set closing flag and wait for all port access are gone */
 263         port->closing = 1;
 264         snd_use_lock_sync(&port->use_lock);
 265
 266         /* clear subscribers info */
 267         clear_subscriber_list(client, port, &port->c_src, SRC_LIST);
 268         clear_subscriber_list(client, port, &port->c_dest, DEST_LIST);
 269
 270         if (port->private_free)
 271                 port->private_free(port->private_data);
 272
 273         snd_BUG_ON(port->c_src.count != 0);
 274         snd_BUG_ON(port->c_dest.count != 0);
 275
 276         kfree(port);
 277         return 0;
 278 }
 279
 280
 281 /* delete a port with the given port id */
 282 int snd_seq_delete_port(struct snd_seq_client *client, int port)
 283 {
 284         unsigned long flags;
 285         struct snd_seq_client_port *found = NULL, *p;
 286
 287         mutex_lock(&client->ports_mutex);
 288         write_lock_irqsave(&client->ports_lock, flags);
 289         list_for_each_entry(p, &client->ports_list_head, list) {
 290                 if (p->addr.port == port) {
 291                         /* ok found.  delete from the list at first */
 292                         list_del(&p->list);
 293                         client->num_ports--;
 294                         found = p;
 295                         break;
 296                 }
 297         }
 298         write_unlock_irqrestore(&client->ports_lock, flags);
 299         mutex_unlock(&client->ports_mutex);
 300         if (found)
 301                 return port_delete(client, found);
 302         else
 303                 return -ENOENT;
 304 }
 305
 306 /* delete the all ports belonging to the given client */
 307 int snd_seq_delete_all_ports(struct snd_seq_client *client)
 308 {
 309         unsigned long flags;
 310         struct list_head deleted_list;
 311         struct snd_seq_client_port *port, *tmp;
 312
 313         /* move the port list to deleted_list, and
 314          * clear the port list in the client data.
 315          */
 316         mutex_lock(&client->ports_mutex);
 317         write_lock_irqsave(&client->ports_lock, flags);
 318         if (! list_empty(&client->ports_list_head)) {
 319                 list_add(&deleted_list, &client->ports_list_head);
 320                 list_del_init(&client->ports_list_head);
 321         } else {
 322                 INIT_LIST_HEAD(&deleted_list);
 323         }
 324         client->num_ports = 0;
 325         write_unlock_irqrestore(&client->ports_lock, flags);
 326
 327         /* remove each port in deleted_list */
 328         list_for_each_entry_safe(port, tmp, &deleted_list, list) {
 329                 list_del(&port->list);
 330                 snd_seq_system_client_ev_port_exit(port->addr.client, port->addr.port);
 331                 port_delete(client, port);
 332         }
 333         mutex_unlock(&client->ports_mutex);
 334         return 0;
 335 }
 336
 337 /* set port info fields */
 338 int snd_seq_set_port_info(struct snd_seq_client_port * port,
 339                           struct snd_seq_port_info * info)
 340 {
 341         if (snd_BUG_ON(!port || !info))
 342                 return -EINVAL;
 343
 344         /* set port name */
 345         if (info->name[0])
 346                 strlcpy(port->name, info->name, sizeof(port->name));
 347
 348         /* set capabilities */
 349         port->capability = info->capability;
 350
 351         /* get port type */
 352         port->type = info->type;
 353
 354         /* information about supported channels/voices */
 355         port->midi_channels = info->midi_channels;
 356         port->midi_voices = info->midi_voices;
 357         port->synth_voices = info->synth_voices;
 358
 359         /* timestamping */
 360         port->timestamping = (info->flags & SNDRV_SEQ_PORT_FLG_TIMESTAMP) ? 1 : 0;
 361         port->time_real = (info->flags & SNDRV_SEQ_PORT_FLG_TIME_REAL) ? 1 : 0;
 362         port->time_queue = info->time_queue;
 363
 364         return 0;
 365 }
 366
 367 /* get port info fields */
 368 int snd_seq_get_port_info(struct snd_seq_client_port * port,
 369                           struct snd_seq_port_info * info)
 370 {
 371         if (snd_BUG_ON(!port || !info))
 372                 return -EINVAL;
 373
 374         /* get port name */
 375         strlcpy(info->name, port->name, sizeof(info->name));
 376
 377         /* get capabilities */
 378         info->capability = port->capability;
 379
 380         /* get port type */
 381         info->type = port->type;
 382
 383         /* information about supported channels/voices */
 384         info->midi_channels = port->midi_channels;
 385         info->midi_voices = port->midi_voices;
 386         info->synth_voices = port->synth_voices;
 387
 388         /* get subscriber counts */
 389         info->read_use = port->c_src.count;
 390         info->write_use = port->c_dest.count;
 391
 392         /* timestamping */
 393         info->flags = 0;
 394         if (port->timestamping) {
 395                 info->flags |= SNDRV_SEQ_PORT_FLG_TIMESTAMP;
 396                 if (port->time_real)
 397                         info->flags |= SNDRV_SEQ_PORT_FLG_TIME_REAL;
 398                 info->time_queue = port->time_queue;
 399         }
 400
 401         return 0;
 402 }
 403
 404
 405
 406 /*
 407  * call callback functions (if any):
 408  * the callbacks are invoked only when the first (for connection) or
 409  * the last subscription (for disconnection) is done.  Second or later
 410  * subscription results in increment of counter, but no callback is
 411  * invoked.
 412  * This feature is useful if these callbacks are associated with
 413  * initialization or termination of devices (see seq_midi.c).
 414  *
 415  * If callback_all option is set, the callback function is invoked
 416  * at each connection/disconnection.
 417  */
 418
 419 static int subscribe_port(struct snd_seq_client *client,
 420                           struct snd_seq_client_port *port,
 421                           struct snd_seq_port_subs_info *grp,
 422                           struct snd_seq_port_subscribe *info,
 423                           int send_ack)
 424 {
 425         int err = 0;
 426
 427         if (!try_module_get(port->owner))
 428                 return -EFAULT;
 429         grp->count++;
 430         if (grp->open && (port->callback_all || grp->count == 1)) {
 431                 err = grp->open(port->private_data, info);
 432                 if (err < 0) {
 433                         module_put(port->owner);
 434                         grp->count--;
 435                 }
 436         }
 437         if (err >= 0 && send_ack && client->type == USER_CLIENT)
 438                 snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
 439                                                    info, SNDRV_SEQ_EVENT_PORT_SUBSCRIBED);
 440
 441         return err;
 442 }
 443
 444 static int unsubscribe_port(struct snd_seq_client *client,
 445                             struct snd_seq_client_port *port,
 446                             struct snd_seq_port_subs_info *grp,
 447                             struct snd_seq_port_subscribe *info,
 448                             int send_ack)
 449 {
 450         int err = 0;
 451
 452         if (! grp->count)
 453                 return -EINVAL;
 454         grp->count--;
 455         if (grp->close && (port->callback_all || grp->count == 0))
 456                 err = grp->close(port->private_data, info);
 457         if (send_ack && client->type == USER_CLIENT)
 458                 snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
 459                                                    info, SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED);
 460         module_put(port->owner);
 461         return err;
 462 }
 463
 464
 465
 466 /* check if both addresses are identical */
 467 static inline int addr_match(struct snd_seq_addr *r, struct snd_seq_addr *s)
 468 {
 469         return (r->client == s->client) && (r->port == s->port);
 470 }
 471
 472 /* check the two subscribe info match */
 473 /* if flags is zero, checks only sender and destination addresses */
 474 static int match_subs_info(struct snd_seq_port_subscribe *r,
 475                            struct snd_seq_port_subscribe *s)
 476 {
 477         if (addr_match(&r->sender, &s->sender) &&
 478             addr_match(&r->dest, &s->dest)) {
 479                 if (r->flags && r->flags == s->flags)
 480                         return r->queue == s->queue;
 481                 else if (! r->flags)
 482                         return 1;
 483         }
 484         return 0;
 485 }
 486
 487
 488 /* connect two ports */
 489 int snd_seq_port_connect(struct snd_seq_client *connector,
 490                          struct snd_seq_client *src_client,
 491                          struct snd_seq_client_port *src_port,
 492                          struct snd_seq_client *dest_client,
 493                          struct snd_seq_client_port *dest_port,
 494                          struct snd_seq_port_subscribe *info)
 495 {
 496         struct snd_seq_port_subs_info *src = &src_port->c_src;
 497         struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
 498         struct snd_seq_subscribers *subs, *s;
 499         int err, src_called = 0;
 500         unsigned long flags;
 501         int exclusive;
 502
 503         subs = kzalloc(sizeof(*subs), GFP_KERNEL);
 504         if (! subs)
 505                 return -ENOMEM;
 506
 507         subs->info = *info;
 508         atomic_set(&subs->ref_count, 2);
 509
 510         down_write(&src->list_mutex);
 511         down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
 512
 513         exclusive = info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE ? 1 : 0;
 514         err = -EBUSY;
 515         if (exclusive) {
 516                 if (! list_empty(&src->list_head) || ! list_empty(&dest->list_head))
 517                         goto __error;
 518         } else {
 519                 if (src->exclusive || dest->exclusive)
 520                         goto __error;
 521                 /* check whether already exists */
 522                 list_for_each_entry(s, &src->list_head, src_list) {
 523                         if (match_subs_info(info, &s->info))
 524                                 goto __error;
 525                 }
 526                 list_for_each_entry(s, &dest->list_head, dest_list) {
 527                         if (match_subs_info(info, &s->info))
 528                                 goto __error;
 529                 }
 530         }
 531
 532         if ((err = subscribe_port(src_client, src_port, src, info,
 533                                   connector->number != src_client->number)) < 0)
 534                 goto __error;
 535         src_called = 1;
 536
 537         if ((err = subscribe_port(dest_client, dest_port, dest, info,
 538                                   connector->number != dest_client->number)) < 0)
 539                 goto __error;
 540
 541         /* add to list */
 542         write_lock_irqsave(&src->list_lock, flags);
 543         // write_lock(&dest->list_lock); // no other lock yet
 544         list_add_tail(&subs->src_list, &src->list_head);
 545         list_add_tail(&subs->dest_list, &dest->list_head);
 546         // write_unlock(&dest->list_lock); // no other lock yet
 547         write_unlock_irqrestore(&src->list_lock, flags);
 548
 549         src->exclusive = dest->exclusive = exclusive;
 550
 551         up_write(&dest->list_mutex);
 552         up_write(&src->list_mutex);
 553         return 0;
 554
 555  __error:
 556         if (src_called)
 557                 unsubscribe_port(src_client, src_port, src, info,
 558                                  connector->number != src_client->number);
 559         kfree(subs);
 560         up_write(&dest->list_mutex);
 561         up_write(&src->list_mutex);
 562         return err;
 563 }
 564
 565
 566 /* remove the connection */
 567 int snd_seq_port_disconnect(struct snd_seq_client *connector,
 568                             struct snd_seq_client *src_client,
 569                             struct snd_seq_client_port *src_port,
 570                             struct snd_seq_client *dest_client,
 571                             struct snd_seq_client_port *dest_port,
 572                             struct snd_seq_port_subscribe *info)
 573 {
 574         struct snd_seq_port_subs_info *src = &src_port->c_src;
 575         struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
 576         struct snd_seq_subscribers *subs;
 577         int err = -ENOENT;
 578         unsigned long flags;
 579
 580         down_write(&src->list_mutex);
 581         down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
 582
 583         /* look for the connection */
 584         list_for_each_entry(subs, &src->list_head, src_list) {
 585                 if (match_subs_info(info, &subs->info)) {
 586                         write_lock_irqsave(&src->list_lock, flags);
 587                         // write_lock(&dest->list_lock);  // no lock yet
 588                         list_del(&subs->src_list);
 589                         list_del(&subs->dest_list);
 590                         // write_unlock(&dest->list_lock);
 591                         write_unlock_irqrestore(&src->list_lock, flags);
 592                         src->exclusive = dest->exclusive = 0;
 593                         unsubscribe_port(src_client, src_port, src, info,
 594                                          connector->number != src_client->number);
 595                         unsubscribe_port(dest_client, dest_port, dest, info,
 596                                          connector->number != dest_client->number);
 597                         kfree(subs);
 598                         err = 0;
 599                         break;
 600                 }
 601         }
 602
 603         up_write(&dest->list_mutex);
 604         up_write(&src->list_mutex);
 605         return err;
 606 }
 607
 608
 609 /* get matched subscriber */
 610 struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
 611                                                           struct snd_seq_addr *dest_addr)
 612 {
 613         struct snd_seq_subscribers *s, *found = NULL;
 614
 615         down_read(&src_grp->list_mutex);
 616         list_for_each_entry(s, &src_grp->list_head, src_list) {
 617                 if (addr_match(dest_addr, &s->info.dest)) {
 618                         found = s;
 619                         break;
 620                 }
 621         }
 622         up_read(&src_grp->list_mutex);
 623         return found;
 624 }
 625
 626 /*
 627  * Attach a device driver that wants to receive events from the
 628  * sequencer.  Returns the new port number on success.
 629  * A driver that wants to receive the events converted to midi, will
 630  * use snd_seq_midisynth_register_port().
 631  */
 632 /* exported */
 633 int snd_seq_event_port_attach(int client,
 634                               struct snd_seq_port_callback *pcbp,
 635                               int cap, int type, int midi_channels,
 636                               int midi_voices, char *portname)
 637 {
 638         struct snd_seq_port_info portinfo;
 639         int  ret;
 640
 641         /* Set up the port */
 642         memset(&portinfo, 0, sizeof(portinfo));
 643         portinfo.addr.client = client;
 644         strlcpy(portinfo.name, portname ? portname : "Unamed port",
 645                 sizeof(portinfo.name));
 646
 647         portinfo.capability = cap;
 648         portinfo.type = type;
 649         portinfo.kernel = pcbp;
 650         portinfo.midi_channels = midi_channels;
 651         portinfo.midi_voices = midi_voices;
 652
 653         /* Create it */
 654         ret = snd_seq_kernel_client_ctl(client,
 655                                         SNDRV_SEQ_IOCTL_CREATE_PORT,
 656                                         &portinfo);
 657
 658         if (ret >= 0)
 659                 ret = portinfo.addr.port;
 660
 661         return ret;
 662 }
 663
 664 EXPORT_SYMBOL(snd_seq_event_port_attach);
 665
 666 /*
 667  * Detach the driver from a port.
 668  */
 669 /* exported */
 670 int snd_seq_event_port_detach(int client, int port)
 671 {
 672         struct snd_seq_port_info portinfo;
 673         int  err;
 674
 675         memset(&portinfo, 0, sizeof(portinfo));
 676         portinfo.addr.client = client;
 677         portinfo.addr.port   = port;
 678         err = snd_seq_kernel_client_ctl(client,
 679                                         SNDRV_SEQ_IOCTL_DELETE_PORT,
 680                                         &portinfo);
 681
 682         return err;
 683 }
 684
 685 EXPORT_SYMBOL(snd_seq_event_port_detach);