git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/pvrusb2/pvrusb2-sysfs.c

   1 /*
   2  *
   3  *
   4  *  Copyright (C) 2005 Mike Isely <isely@pobox.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include <linux/string.h>
  22 #include <linux/slab.h>
  23 #include "pvrusb2-sysfs.h"
  24 #include "pvrusb2-hdw.h"
  25 #include "pvrusb2-debug.h"
  26 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
  27 #include "pvrusb2-debugifc.h"
  28 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
  29
  30 #define pvr2_sysfs_trace(...) pvr2_trace(PVR2_TRACE_SYSFS,__VA_ARGS__)
  31
  32 struct pvr2_sysfs {
  33         struct pvr2_channel channel;
  34         struct device *class_dev;
  35 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
  36         struct pvr2_sysfs_debugifc *debugifc;
  37 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
  38         struct pvr2_sysfs_ctl_item *item_first;
  39         struct pvr2_sysfs_ctl_item *item_last;
  40         struct device_attribute attr_v4l_minor_number;
  41         struct device_attribute attr_v4l_radio_minor_number;
  42         struct device_attribute attr_unit_number;
  43         struct device_attribute attr_bus_info;
  44         struct device_attribute attr_hdw_name;
  45         struct device_attribute attr_hdw_desc;
  46         int v4l_minor_number_created_ok;
  47         int v4l_radio_minor_number_created_ok;
  48         int unit_number_created_ok;
  49         int bus_info_created_ok;
  50         int hdw_name_created_ok;
  51         int hdw_desc_created_ok;
  52 };
  53
  54 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
  55 struct pvr2_sysfs_debugifc {
  56         struct device_attribute attr_debugcmd;
  57         struct device_attribute attr_debuginfo;
  58         int debugcmd_created_ok;
  59         int debuginfo_created_ok;
  60 };
  61 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
  62
  63 struct pvr2_sysfs_ctl_item {
  64         struct device_attribute attr_name;
  65         struct device_attribute attr_type;
  66         struct device_attribute attr_min;
  67         struct device_attribute attr_max;
  68         struct device_attribute attr_def;
  69         struct device_attribute attr_enum;
  70         struct device_attribute attr_bits;
  71         struct device_attribute attr_val;
  72         struct device_attribute attr_custom;
  73         struct pvr2_ctrl *cptr;
  74         int ctl_id;
  75         struct pvr2_sysfs *chptr;
  76         struct pvr2_sysfs_ctl_item *item_next;
  77         struct attribute *attr_gen[7];
  78         struct attribute_group grp;
  79         int created_ok;
  80         char name[80];
  81 };
  82
  83 struct pvr2_sysfs_class {
  84         struct class class;
  85 };
  86
  87 static ssize_t show_name(struct device *class_dev,
  88                          struct device_attribute *attr,
  89                          char *buf)
  90 {
  91         struct pvr2_sysfs_ctl_item *cip;
  92         const char *name;
  93         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_name);
  94         name = pvr2_ctrl_get_desc(cip->cptr);
  95         pvr2_sysfs_trace("pvr2_sysfs(%p) show_name(cid=%d) is %s",
  96                          cip->chptr, cip->ctl_id, name);
  97         if (!name) return -EINVAL;
  98         return scnprintf(buf, PAGE_SIZE, "%s\n", name);
  99 }
 100
 101 static ssize_t show_type(struct device *class_dev,
 102                          struct device_attribute *attr,
 103                          char *buf)
 104 {
 105         struct pvr2_sysfs_ctl_item *cip;
 106         const char *name;
 107         enum pvr2_ctl_type tp;
 108         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_type);
 109         tp = pvr2_ctrl_get_type(cip->cptr);
 110         switch (tp) {
 111         case pvr2_ctl_int: name = "integer"; break;
 112         case pvr2_ctl_enum: name = "enum"; break;
 113         case pvr2_ctl_bitmask: name = "bitmask"; break;
 114         case pvr2_ctl_bool: name = "boolean"; break;
 115         default: name = "?"; break;
 116         }
 117         pvr2_sysfs_trace("pvr2_sysfs(%p) show_type(cid=%d) is %s",
 118                          cip->chptr, cip->ctl_id, name);
 119         if (!name) return -EINVAL;
 120         return scnprintf(buf, PAGE_SIZE, "%s\n", name);
 121 }
 122
 123 static ssize_t show_min(struct device *class_dev,
 124                         struct device_attribute *attr,
 125                         char *buf)
 126 {
 127         struct pvr2_sysfs_ctl_item *cip;
 128         long val;
 129         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_min);
 130         val = pvr2_ctrl_get_min(cip->cptr);
 131         pvr2_sysfs_trace("pvr2_sysfs(%p) show_min(cid=%d) is %ld",
 132                          cip->chptr, cip->ctl_id, val);
 133         return scnprintf(buf, PAGE_SIZE, "%ld\n", val);
 134 }
 135
 136 static ssize_t show_max(struct device *class_dev,
 137                         struct device_attribute *attr,
 138                         char *buf)
 139 {
 140         struct pvr2_sysfs_ctl_item *cip;
 141         long val;
 142         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_max);
 143         val = pvr2_ctrl_get_max(cip->cptr);
 144         pvr2_sysfs_trace("pvr2_sysfs(%p) show_max(cid=%d) is %ld",
 145                          cip->chptr, cip->ctl_id, val);
 146         return scnprintf(buf, PAGE_SIZE, "%ld\n", val);
 147 }
 148
 149 static ssize_t show_def(struct device *class_dev,
 150                         struct device_attribute *attr,
 151                         char *buf)
 152 {
 153         struct pvr2_sysfs_ctl_item *cip;
 154         int val;
 155         int ret;
 156         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_def);
 157         ret = pvr2_ctrl_get_def(cip->cptr, &val);
 158         pvr2_sysfs_trace("pvr2_sysfs(%p) show_def(cid=%d) is %d, stat=%d",
 159                          cip->chptr, cip->ctl_id, val, ret);
 160         if (ret < 0) {
 161                 return ret;
 162         }
 163         return scnprintf(buf, PAGE_SIZE, "%d\n", val);
 164 }
 165
 166 static ssize_t show_val_norm(struct device *class_dev,
 167                              struct device_attribute *attr,
 168                              char *buf)
 169 {
 170         struct pvr2_sysfs_ctl_item *cip;
 171         int val;
 172         int ret;
 173         unsigned int cnt = 0;
 174         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_val);
 175         ret = pvr2_ctrl_get_value(cip->cptr, &val);
 176         if (ret < 0) return ret;
 177         ret = pvr2_ctrl_value_to_sym(cip->cptr, ~0, val,
 178                                      buf, PAGE_SIZE - 1, &cnt);
 179         pvr2_sysfs_trace("pvr2_sysfs(%p) show_val_norm(cid=%d) is %.*s (%d)",
 180                          cip->chptr, cip->ctl_id, cnt, buf, val);
 181         buf[cnt] = '\n';
 182         return cnt+1;
 183 }
 184
 185 static ssize_t show_val_custom(struct device *class_dev,
 186                                struct device_attribute *attr,
 187                                char *buf)
 188 {
 189         struct pvr2_sysfs_ctl_item *cip;
 190         int val;
 191         int ret;
 192         unsigned int cnt = 0;
 193         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_custom);
 194         ret = pvr2_ctrl_get_value(cip->cptr, &val);
 195         if (ret < 0) return ret;
 196         ret = pvr2_ctrl_custom_value_to_sym(cip->cptr, ~0, val,
 197                                             buf, PAGE_SIZE - 1, &cnt);
 198         pvr2_sysfs_trace("pvr2_sysfs(%p) show_val_custom(cid=%d) is %.*s (%d)",
 199                          cip->chptr, cip->ctl_id, cnt, buf, val);
 200         buf[cnt] = '\n';
 201         return cnt+1;
 202 }
 203
 204 static ssize_t show_enum(struct device *class_dev,
 205                          struct device_attribute *attr,
 206                          char *buf)
 207 {
 208         struct pvr2_sysfs_ctl_item *cip;
 209         long val;
 210         unsigned int bcnt, ccnt, ecnt;
 211         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_enum);
 212         ecnt = pvr2_ctrl_get_cnt(cip->cptr);
 213         bcnt = 0;
 214         for (val = 0; val < ecnt; val++) {
 215                 pvr2_ctrl_get_valname(cip->cptr, val, buf + bcnt,
 216                                       PAGE_SIZE - bcnt, &ccnt);
 217                 if (!ccnt) continue;
 218                 bcnt += ccnt;
 219                 if (bcnt >= PAGE_SIZE) break;
 220                 buf[bcnt] = '\n';
 221                 bcnt++;
 222         }
 223         pvr2_sysfs_trace("pvr2_sysfs(%p) show_enum(cid=%d)",
 224                          cip->chptr, cip->ctl_id);
 225         return bcnt;
 226 }
 227
 228 static ssize_t show_bits(struct device *class_dev,
 229                          struct device_attribute *attr,
 230                          char *buf)
 231 {
 232         struct pvr2_sysfs_ctl_item *cip;
 233         int valid_bits, msk;
 234         unsigned int bcnt, ccnt;
 235         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_bits);
 236         valid_bits = pvr2_ctrl_get_mask(cip->cptr);
 237         bcnt = 0;
 238         for (msk = 1; valid_bits; msk <<= 1) {
 239                 if (!(msk & valid_bits)) continue;
 240                 valid_bits &= ~msk;
 241                 pvr2_ctrl_get_valname(cip->cptr, msk, buf + bcnt,
 242                                       PAGE_SIZE - bcnt, &ccnt);
 243                 bcnt += ccnt;
 244                 if (bcnt >= PAGE_SIZE) break;
 245                 buf[bcnt] = '\n';
 246                 bcnt++;
 247         }
 248         pvr2_sysfs_trace("pvr2_sysfs(%p) show_bits(cid=%d)",
 249                          cip->chptr, cip->ctl_id);
 250         return bcnt;
 251 }
 252
 253 static int store_val_any(struct pvr2_sysfs_ctl_item *cip, int customfl,
 254                          const char *buf,unsigned int count)
 255 {
 256         int ret;
 257         int mask,val;
 258         if (customfl) {
 259                 ret = pvr2_ctrl_custom_sym_to_value(cip->cptr, buf, count,
 260                                                     &mask, &val);
 261         } else {
 262                 ret = pvr2_ctrl_sym_to_value(cip->cptr, buf, count,
 263                                              &mask, &val);
 264         }
 265         if (ret < 0) return ret;
 266         ret = pvr2_ctrl_set_mask_value(cip->cptr, mask, val);
 267         pvr2_hdw_commit_ctl(cip->chptr->channel.hdw);
 268         return ret;
 269 }
 270
 271 static ssize_t store_val_norm(struct device *class_dev,
 272                               struct device_attribute *attr,
 273                               const char *buf, size_t count)
 274 {
 275         struct pvr2_sysfs_ctl_item *cip;
 276         int ret;
 277         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_val);
 278         pvr2_sysfs_trace("pvr2_sysfs(%p) store_val_norm(cid=%d) \"%.*s\"",
 279                          cip->chptr, cip->ctl_id, (int)count, buf);
 280         ret = store_val_any(cip, 0, buf, count);
 281         if (!ret) ret = count;
 282         return ret;
 283 }
 284
 285 static ssize_t store_val_custom(struct device *class_dev,
 286                                 struct device_attribute *attr,
 287                                 const char *buf, size_t count)
 288 {
 289         struct pvr2_sysfs_ctl_item *cip;
 290         int ret;
 291         cip = container_of(attr, struct pvr2_sysfs_ctl_item, attr_custom);
 292         pvr2_sysfs_trace("pvr2_sysfs(%p) store_val_custom(cid=%d) \"%.*s\"",
 293                          cip->chptr, cip->ctl_id, (int)count, buf);
 294         ret = store_val_any(cip, 1, buf, count);
 295         if (!ret) ret = count;
 296         return ret;
 297 }
 298
 299 static void pvr2_sysfs_add_control(struct pvr2_sysfs *sfp,int ctl_id)
 300 {
 301         struct pvr2_sysfs_ctl_item *cip;
 302         struct pvr2_ctrl *cptr;
 303         unsigned int cnt,acnt;
 304         int ret;
 305
 306         cptr = pvr2_hdw_get_ctrl_by_index(sfp->channel.hdw,ctl_id);
 307         if (!cptr) return;
 308
 309         cip = kzalloc(sizeof(*cip),GFP_KERNEL);
 310         if (!cip) return;
 311         pvr2_sysfs_trace("Creating pvr2_sysfs_ctl_item id=%p",cip);
 312
 313         cip->cptr = cptr;
 314         cip->ctl_id = ctl_id;
 315
 316         cip->chptr = sfp;
 317         cip->item_next = NULL;
 318         if (sfp->item_last) {
 319                 sfp->item_last->item_next = cip;
 320         } else {
 321                 sfp->item_first = cip;
 322         }
 323         sfp->item_last = cip;
 324
 325         cip->attr_name.attr.name = "name";
 326         cip->attr_name.attr.mode = S_IRUGO;
 327         cip->attr_name.show = show_name;
 328
 329         cip->attr_type.attr.name = "type";
 330         cip->attr_type.attr.mode = S_IRUGO;
 331         cip->attr_type.show = show_type;
 332
 333         cip->attr_min.attr.name = "min_val";
 334         cip->attr_min.attr.mode = S_IRUGO;
 335         cip->attr_min.show = show_min;
 336
 337         cip->attr_max.attr.name = "max_val";
 338         cip->attr_max.attr.mode = S_IRUGO;
 339         cip->attr_max.show = show_max;
 340
 341         cip->attr_def.attr.name = "def_val";
 342         cip->attr_def.attr.mode = S_IRUGO;
 343         cip->attr_def.show = show_def;
 344
 345         cip->attr_val.attr.name = "cur_val";
 346         cip->attr_val.attr.mode = S_IRUGO;
 347
 348         cip->attr_custom.attr.name = "custom_val";
 349         cip->attr_custom.attr.mode = S_IRUGO;
 350
 351         cip->attr_enum.attr.name = "enum_val";
 352         cip->attr_enum.attr.mode = S_IRUGO;
 353         cip->attr_enum.show = show_enum;
 354
 355         cip->attr_bits.attr.name = "bit_val";
 356         cip->attr_bits.attr.mode = S_IRUGO;
 357         cip->attr_bits.show = show_bits;
 358
 359         if (pvr2_ctrl_is_writable(cptr)) {
 360                 cip->attr_val.attr.mode |= S_IWUSR|S_IWGRP;
 361                 cip->attr_custom.attr.mode |= S_IWUSR|S_IWGRP;
 362         }
 363
 364         acnt = 0;
 365         cip->attr_gen[acnt++] = &cip->attr_name.attr;
 366         cip->attr_gen[acnt++] = &cip->attr_type.attr;
 367         cip->attr_gen[acnt++] = &cip->attr_val.attr;
 368         cip->attr_gen[acnt++] = &cip->attr_def.attr;
 369         cip->attr_val.show = show_val_norm;
 370         cip->attr_val.store = store_val_norm;
 371         if (pvr2_ctrl_has_custom_symbols(cptr)) {
 372                 cip->attr_gen[acnt++] = &cip->attr_custom.attr;
 373                 cip->attr_custom.show = show_val_custom;
 374                 cip->attr_custom.store = store_val_custom;
 375         }
 376         switch (pvr2_ctrl_get_type(cptr)) {
 377         case pvr2_ctl_enum:
 378                 // Control is an enumeration
 379                 cip->attr_gen[acnt++] = &cip->attr_enum.attr;
 380                 break;
 381         case pvr2_ctl_int:
 382                 // Control is an integer
 383                 cip->attr_gen[acnt++] = &cip->attr_min.attr;
 384                 cip->attr_gen[acnt++] = &cip->attr_max.attr;
 385                 break;
 386         case pvr2_ctl_bitmask:
 387                 // Control is an bitmask
 388                 cip->attr_gen[acnt++] = &cip->attr_bits.attr;
 389                 break;
 390         default: break;
 391         }
 392
 393         cnt = scnprintf(cip->name,sizeof(cip->name)-1,"ctl_%s",
 394                         pvr2_ctrl_get_name(cptr));
 395         cip->name[cnt] = 0;
 396         cip->grp.name = cip->name;
 397         cip->grp.attrs = cip->attr_gen;
 398
 399         ret = sysfs_create_group(&sfp->class_dev->kobj,&cip->grp);
 400         if (ret) {
 401                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 402                            "sysfs_create_group error: %d",
 403                            ret);
 404                 return;
 405         }
 406         cip->created_ok = !0;
 407 }
 408
 409 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
 410 static ssize_t debuginfo_show(struct device *, struct device_attribute *,
 411                               char *);
 412 static ssize_t debugcmd_show(struct device *, struct device_attribute *,
 413                              char *);
 414 static ssize_t debugcmd_store(struct device *, struct device_attribute *,
 415                               const char *, size_t count);
 416
 417 static void pvr2_sysfs_add_debugifc(struct pvr2_sysfs *sfp)
 418 {
 419         struct pvr2_sysfs_debugifc *dip;
 420         int ret;
 421
 422         dip = kzalloc(sizeof(*dip),GFP_KERNEL);
 423         if (!dip) return;
 424         dip->attr_debugcmd.attr.name = "debugcmd";
 425         dip->attr_debugcmd.attr.mode = S_IRUGO|S_IWUSR|S_IWGRP;
 426         dip->attr_debugcmd.show = debugcmd_show;
 427         dip->attr_debugcmd.store = debugcmd_store;
 428         dip->attr_debuginfo.attr.name = "debuginfo";
 429         dip->attr_debuginfo.attr.mode = S_IRUGO;
 430         dip->attr_debuginfo.show = debuginfo_show;
 431         sfp->debugifc = dip;
 432         ret = device_create_file(sfp->class_dev,&dip->attr_debugcmd);
 433         if (ret < 0) {
 434                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 435                            "device_create_file error: %d",
 436                            ret);
 437         } else {
 438                 dip->debugcmd_created_ok = !0;
 439         }
 440         ret = device_create_file(sfp->class_dev,&dip->attr_debuginfo);
 441         if (ret < 0) {
 442                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 443                            "device_create_file error: %d",
 444                            ret);
 445         } else {
 446                 dip->debuginfo_created_ok = !0;
 447         }
 448 }
 449
 450
 451 static void pvr2_sysfs_tear_down_debugifc(struct pvr2_sysfs *sfp)
 452 {
 453         if (!sfp->debugifc) return;
 454         if (sfp->debugifc->debuginfo_created_ok) {
 455                 device_remove_file(sfp->class_dev,
 456                                          &sfp->debugifc->attr_debuginfo);
 457         }
 458         if (sfp->debugifc->debugcmd_created_ok) {
 459                 device_remove_file(sfp->class_dev,
 460                                          &sfp->debugifc->attr_debugcmd);
 461         }
 462         kfree(sfp->debugifc);
 463         sfp->debugifc = NULL;
 464 }
 465 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
 466
 467
 468 static void pvr2_sysfs_add_controls(struct pvr2_sysfs *sfp)
 469 {
 470         unsigned int idx,cnt;
 471         cnt = pvr2_hdw_get_ctrl_count(sfp->channel.hdw);
 472         for (idx = 0; idx < cnt; idx++) {
 473                 pvr2_sysfs_add_control(sfp,idx);
 474         }
 475 }
 476
 477
 478 static void pvr2_sysfs_tear_down_controls(struct pvr2_sysfs *sfp)
 479 {
 480         struct pvr2_sysfs_ctl_item *cip1,*cip2;
 481         for (cip1 = sfp->item_first; cip1; cip1 = cip2) {
 482                 cip2 = cip1->item_next;
 483                 if (cip1->created_ok) {
 484                         sysfs_remove_group(&sfp->class_dev->kobj,&cip1->grp);
 485                 }
 486                 pvr2_sysfs_trace("Destroying pvr2_sysfs_ctl_item id=%p",cip1);
 487                 kfree(cip1);
 488         }
 489 }
 490
 491
 492 static void pvr2_sysfs_class_release(struct class *class)
 493 {
 494         struct pvr2_sysfs_class *clp;
 495         clp = container_of(class,struct pvr2_sysfs_class,class);
 496         pvr2_sysfs_trace("Destroying pvr2_sysfs_class id=%p",clp);
 497         kfree(clp);
 498 }
 499
 500
 501 static void pvr2_sysfs_release(struct device *class_dev)
 502 {
 503         pvr2_sysfs_trace("Releasing class_dev id=%p",class_dev);
 504         kfree(class_dev);
 505 }
 506
 507
 508 static void class_dev_destroy(struct pvr2_sysfs *sfp)
 509 {
 510         if (!sfp->class_dev) return;
 511 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
 512         pvr2_sysfs_tear_down_debugifc(sfp);
 513 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
 514         pvr2_sysfs_tear_down_controls(sfp);
 515         if (sfp->hdw_desc_created_ok) {
 516                 device_remove_file(sfp->class_dev,
 517                                    &sfp->attr_hdw_desc);
 518         }
 519         if (sfp->hdw_name_created_ok) {
 520                 device_remove_file(sfp->class_dev,
 521                                    &sfp->attr_hdw_name);
 522         }
 523         if (sfp->bus_info_created_ok) {
 524                 device_remove_file(sfp->class_dev,
 525                                          &sfp->attr_bus_info);
 526         }
 527         if (sfp->v4l_minor_number_created_ok) {
 528                 device_remove_file(sfp->class_dev,
 529                                          &sfp->attr_v4l_minor_number);
 530         }
 531         if (sfp->v4l_radio_minor_number_created_ok) {
 532                 device_remove_file(sfp->class_dev,
 533                                          &sfp->attr_v4l_radio_minor_number);
 534         }
 535         if (sfp->unit_number_created_ok) {
 536                 device_remove_file(sfp->class_dev,
 537                                          &sfp->attr_unit_number);
 538         }
 539         pvr2_sysfs_trace("Destroying class_dev id=%p",sfp->class_dev);
 540         sfp->class_dev->driver_data = NULL;
 541         device_unregister(sfp->class_dev);
 542         sfp->class_dev = NULL;
 543 }
 544
 545
 546 static ssize_t v4l_minor_number_show(struct device *class_dev,
 547                                      struct device_attribute *attr, char *buf)
 548 {
 549         struct pvr2_sysfs *sfp;
 550         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 551         if (!sfp) return -EINVAL;
 552         return scnprintf(buf,PAGE_SIZE,"%d\n",
 553                          pvr2_hdw_v4l_get_minor_number(sfp->channel.hdw,
 554                                                        pvr2_v4l_type_video));
 555 }
 556
 557
 558 static ssize_t bus_info_show(struct device *class_dev,
 559                              struct device_attribute *attr, char *buf)
 560 {
 561         struct pvr2_sysfs *sfp;
 562         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 563         if (!sfp) return -EINVAL;
 564         return scnprintf(buf,PAGE_SIZE,"%s\n",
 565                          pvr2_hdw_get_bus_info(sfp->channel.hdw));
 566 }
 567
 568
 569 static ssize_t hdw_name_show(struct device *class_dev,
 570                              struct device_attribute *attr, char *buf)
 571 {
 572         struct pvr2_sysfs *sfp;
 573         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 574         if (!sfp) return -EINVAL;
 575         return scnprintf(buf,PAGE_SIZE,"%s\n",
 576                          pvr2_hdw_get_type(sfp->channel.hdw));
 577 }
 578
 579
 580 static ssize_t hdw_desc_show(struct device *class_dev,
 581                              struct device_attribute *attr, char *buf)
 582 {
 583         struct pvr2_sysfs *sfp;
 584         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 585         if (!sfp) return -EINVAL;
 586         return scnprintf(buf,PAGE_SIZE,"%s\n",
 587                          pvr2_hdw_get_desc(sfp->channel.hdw));
 588 }
 589
 590
 591 static ssize_t v4l_radio_minor_number_show(struct device *class_dev,
 592                                            struct device_attribute *attr,
 593                                            char *buf)
 594 {
 595         struct pvr2_sysfs *sfp;
 596         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 597         if (!sfp) return -EINVAL;
 598         return scnprintf(buf,PAGE_SIZE,"%d\n",
 599                          pvr2_hdw_v4l_get_minor_number(sfp->channel.hdw,
 600                                                        pvr2_v4l_type_radio));
 601 }
 602
 603
 604 static ssize_t unit_number_show(struct device *class_dev,
 605                                 struct device_attribute *attr, char *buf)
 606 {
 607         struct pvr2_sysfs *sfp;
 608         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 609         if (!sfp) return -EINVAL;
 610         return scnprintf(buf,PAGE_SIZE,"%d\n",
 611                          pvr2_hdw_get_unit_number(sfp->channel.hdw));
 612 }
 613
 614
 615 static void class_dev_create(struct pvr2_sysfs *sfp,
 616                              struct pvr2_sysfs_class *class_ptr)
 617 {
 618         struct usb_device *usb_dev;
 619         struct device *class_dev;
 620         int ret;
 621
 622         usb_dev = pvr2_hdw_get_dev(sfp->channel.hdw);
 623         if (!usb_dev) return;
 624         class_dev = kzalloc(sizeof(*class_dev),GFP_KERNEL);
 625         if (!class_dev) return;
 626
 627         pvr2_sysfs_trace("Creating class_dev id=%p",class_dev);
 628
 629         class_dev->class = &class_ptr->class;
 630         dev_set_name(class_dev, "%s",
 631                      pvr2_hdw_get_device_identifier(sfp->channel.hdw));
 632
 633         class_dev->parent = &usb_dev->dev;
 634
 635         sfp->class_dev = class_dev;
 636         class_dev->driver_data = sfp;
 637         ret = device_register(class_dev);
 638         if (ret) {
 639                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 640                            "device_register failed");
 641                 kfree(class_dev);
 642                 return;
 643         }
 644
 645         sfp->attr_v4l_minor_number.attr.name = "v4l_minor_number";
 646         sfp->attr_v4l_minor_number.attr.mode = S_IRUGO;
 647         sfp->attr_v4l_minor_number.show = v4l_minor_number_show;
 648         sfp->attr_v4l_minor_number.store = NULL;
 649         ret = device_create_file(sfp->class_dev,
 650                                        &sfp->attr_v4l_minor_number);
 651         if (ret < 0) {
 652                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 653                            "device_create_file error: %d",
 654                            ret);
 655         } else {
 656                 sfp->v4l_minor_number_created_ok = !0;
 657         }
 658
 659         sfp->attr_v4l_radio_minor_number.attr.name = "v4l_radio_minor_number";
 660         sfp->attr_v4l_radio_minor_number.attr.mode = S_IRUGO;
 661         sfp->attr_v4l_radio_minor_number.show = v4l_radio_minor_number_show;
 662         sfp->attr_v4l_radio_minor_number.store = NULL;
 663         ret = device_create_file(sfp->class_dev,
 664                                        &sfp->attr_v4l_radio_minor_number);
 665         if (ret < 0) {
 666                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 667                            "device_create_file error: %d",
 668                            ret);
 669         } else {
 670                 sfp->v4l_radio_minor_number_created_ok = !0;
 671         }
 672
 673         sfp->attr_unit_number.attr.name = "unit_number";
 674         sfp->attr_unit_number.attr.mode = S_IRUGO;
 675         sfp->attr_unit_number.show = unit_number_show;
 676         sfp->attr_unit_number.store = NULL;
 677         ret = device_create_file(sfp->class_dev,&sfp->attr_unit_number);
 678         if (ret < 0) {
 679                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 680                            "device_create_file error: %d",
 681                            ret);
 682         } else {
 683                 sfp->unit_number_created_ok = !0;
 684         }
 685
 686         sfp->attr_bus_info.attr.name = "bus_info_str";
 687         sfp->attr_bus_info.attr.mode = S_IRUGO;
 688         sfp->attr_bus_info.show = bus_info_show;
 689         sfp->attr_bus_info.store = NULL;
 690         ret = device_create_file(sfp->class_dev,
 691                                        &sfp->attr_bus_info);
 692         if (ret < 0) {
 693                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 694                            "device_create_file error: %d",
 695                            ret);
 696         } else {
 697                 sfp->bus_info_created_ok = !0;
 698         }
 699
 700         sfp->attr_hdw_name.attr.name = "device_hardware_type";
 701         sfp->attr_hdw_name.attr.mode = S_IRUGO;
 702         sfp->attr_hdw_name.show = hdw_name_show;
 703         sfp->attr_hdw_name.store = NULL;
 704         ret = device_create_file(sfp->class_dev,
 705                                  &sfp->attr_hdw_name);
 706         if (ret < 0) {
 707                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 708                            "device_create_file error: %d",
 709                            ret);
 710         } else {
 711                 sfp->hdw_name_created_ok = !0;
 712         }
 713
 714         sfp->attr_hdw_desc.attr.name = "device_hardware_description";
 715         sfp->attr_hdw_desc.attr.mode = S_IRUGO;
 716         sfp->attr_hdw_desc.show = hdw_desc_show;
 717         sfp->attr_hdw_desc.store = NULL;
 718         ret = device_create_file(sfp->class_dev,
 719                                  &sfp->attr_hdw_desc);
 720         if (ret < 0) {
 721                 pvr2_trace(PVR2_TRACE_ERROR_LEGS,
 722                            "device_create_file error: %d",
 723                            ret);
 724         } else {
 725                 sfp->hdw_desc_created_ok = !0;
 726         }
 727
 728         pvr2_sysfs_add_controls(sfp);
 729 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
 730         pvr2_sysfs_add_debugifc(sfp);
 731 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
 732 }
 733
 734
 735 static void pvr2_sysfs_internal_check(struct pvr2_channel *chp)
 736 {
 737         struct pvr2_sysfs *sfp;
 738         sfp = container_of(chp,struct pvr2_sysfs,channel);
 739         if (!sfp->channel.mc_head->disconnect_flag) return;
 740         pvr2_trace(PVR2_TRACE_STRUCT,"Destroying pvr2_sysfs id=%p",sfp);
 741         class_dev_destroy(sfp);
 742         pvr2_channel_done(&sfp->channel);
 743         kfree(sfp);
 744 }
 745
 746
 747 struct pvr2_sysfs *pvr2_sysfs_create(struct pvr2_context *mp,
 748                                      struct pvr2_sysfs_class *class_ptr)
 749 {
 750         struct pvr2_sysfs *sfp;
 751         sfp = kzalloc(sizeof(*sfp),GFP_KERNEL);
 752         if (!sfp) return sfp;
 753         pvr2_trace(PVR2_TRACE_STRUCT,"Creating pvr2_sysfs id=%p",sfp);
 754         pvr2_channel_init(&sfp->channel,mp);
 755         sfp->channel.check_func = pvr2_sysfs_internal_check;
 756
 757         class_dev_create(sfp,class_ptr);
 758         return sfp;
 759 }
 760
 761
 762
 763 struct pvr2_sysfs_class *pvr2_sysfs_class_create(void)
 764 {
 765         struct pvr2_sysfs_class *clp;
 766         clp = kzalloc(sizeof(*clp),GFP_KERNEL);
 767         if (!clp) return clp;
 768         pvr2_sysfs_trace("Creating pvr2_sysfs_class id=%p",clp);
 769         clp->class.name = "pvrusb2";
 770         clp->class.class_release = pvr2_sysfs_class_release;
 771         clp->class.dev_release = pvr2_sysfs_release;
 772         if (class_register(&clp->class)) {
 773                 pvr2_sysfs_trace(
 774                         "Registration failed for pvr2_sysfs_class id=%p",clp);
 775                 kfree(clp);
 776                 clp = NULL;
 777         }
 778         return clp;
 779 }
 780
 781
 782 void pvr2_sysfs_class_destroy(struct pvr2_sysfs_class *clp)
 783 {
 784         class_unregister(&clp->class);
 785 }
 786
 787
 788 #ifdef CONFIG_VIDEO_PVRUSB2_DEBUGIFC
 789 static ssize_t debuginfo_show(struct device *class_dev,
 790                               struct device_attribute *attr, char *buf)
 791 {
 792         struct pvr2_sysfs *sfp;
 793         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 794         if (!sfp) return -EINVAL;
 795         pvr2_hdw_trigger_module_log(sfp->channel.hdw);
 796         return pvr2_debugifc_print_info(sfp->channel.hdw,buf,PAGE_SIZE);
 797 }
 798
 799
 800 static ssize_t debugcmd_show(struct device *class_dev,
 801                              struct device_attribute *attr, char *buf)
 802 {
 803         struct pvr2_sysfs *sfp;
 804         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 805         if (!sfp) return -EINVAL;
 806         return pvr2_debugifc_print_status(sfp->channel.hdw,buf,PAGE_SIZE);
 807 }
 808
 809
 810 static ssize_t debugcmd_store(struct device *class_dev,
 811                               struct device_attribute *attr,
 812                               const char *buf, size_t count)
 813 {
 814         struct pvr2_sysfs *sfp;
 815         int ret;
 816
 817         sfp = (struct pvr2_sysfs *)class_dev->driver_data;
 818         if (!sfp) return -EINVAL;
 819
 820         ret = pvr2_debugifc_docmd(sfp->channel.hdw,buf,count);
 821         if (ret < 0) return ret;
 822         return count;
 823 }
 824 #endif /* CONFIG_VIDEO_PVRUSB2_DEBUGIFC */
 825
 826
 827 /*
 828   Stuff for Emacs to see, in order to encourage consistent editing style:
 829   *** Local Variables: ***
 830   *** mode: c ***
 831   *** fill-column: 75 ***
 832   *** tab-width: 8 ***
 833   *** c-basic-offset: 8 ***
 834   *** End: ***
 835   */