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